import { useCompanyStore } from "@/stores/company"
import { ThrottleCacheControl } from "@/utils/DebounceAndThrottle"
import { processArrays } from "@/utils/meterUtils"
import request from "@/utils/request"
import dayjs from "dayjs"
/**
 * 获取表计信息的API
 * @param {Object} params - 请求参数
 * @param {number} [params.company_id] - 公司ID，如果不传则使用当前公司ID
 * @param {string} [params.type] - 表计类型
 * @param {number} [params.meter_code] - 表计编码
 * @returns {Promise<{
 *   code: number,
 *   data: Array<{
 *     id: number,                      // 表计ID
 *     company_id: number,              // 公司ID
 *     meter_code: string,              // 表计编码
 *     meter_id: string,                // 表计外部ID
 *     parent_id: number,               // 父级表计ID
 *     type: number,                    // 表计类型
 *     specification: string,           // 规格
 *     installation_date: string,       // 安装日期
 *     status: number,                  // 状态
 *     manufacturer: string,            // 制造商
 *     remarks: string,                 // 备注
 *     installation_location: string,   // 安装位置
 *     area_id: number,                 // 区域ID
 *     sub_category1: string,           // 一级分类
 *     sub_category2: string,           // 二级分类
 *     sub_category3: string,           // 三级分类
 *     sub_category4: string,           // 四级分类
 *     latitude: number,                // 纬度
 *     longitude: number,               // 经度
 *     engine_id: number,               // 引擎ID
 *     device_id: number|null,          // 设备ID
 *     icon: number,                    // 图标
 *     CSQ: number,                     // 信号强度
 *     bottom_value: number,            // 启表底数
 *     multiple: number,                // 倍率
 *     is_drain_considerd: boolean,     // 是否参与漏水统计
 *     supply_region: string,           // 供应点位
 *     standard_coal_factor: string,    // 折标煤系数
 *     price_rule_id: number|null,      // 价格规则ID
 *     created_at: string,              // 创建时间
 *     updated_at: string               // 更新时间
 *   }>
 * }>} 返回表计信息列表的Promise
 */
export const getMeterInfoApi = (params = {}) => {
    return request.get('/meters/', {
        params: {
            company_id: useCompanyStore().currentCompany.id,
            ...params
        }
    })
}
// 获取一级仪表列表的函数
export async function getFirstLevelMeterList(data) {
    // 创建仪表列表的具体实现
    const meterListControl = new ThrottleCacheControl({
        throttleDelay: 2000,
        cacheDuration: 5 * 60 * 1000,
        cacheKeyGenerator: (data) => `${data.company_id}_${data.type}`,
        dataProcessor: (response) => response.data.filter(item => !item.parent_id)
    });
    return meterListControl.request(data, getMeterInfoApi);
}


// 清除缓存的方法
export function clearMeterListCache() {
    meterListControl.clearCache();
}


export const addMeterApi = (data) => {
    return request.post('/meters/', data)
}

export const deleteMeterApi = (id) => {
    return request.delete('/meters/', {
        data: {
            id
        }
    })
}

export const updateMeterApi = (data) => {
    return request.patch('/meters/', data)
}

//管线
export const getPipelineInfoApi = (params = {}) => {
    return request.get('/pipeline/', { params })
}
export const addPipelineApi = (data) => {
    return request.post('/pipeline/', data)
}
export const deletePipelineApi = (id) => {
    return request.delete('/pipeline/', {
        data: {
            id: '' + id
        }
    })
}
export const updatePipelineApi = (data) => {
    return request.patch('/pipeline/', data)
}
export const getMeterDetailApi = (params = {}) => {
    return request.get('/detail/', { params })
}

function sortTimeSeriesData(res) {
    if (!res?.aggregated_data || !Array.isArray(res.aggregated_data)) {
        return res;
    }

    return {
        ...res,
        aggregated_data: res.aggregated_data.sort((a, b) =>
            new Date(a.start_time) - new Date(b.start_time)
        )
    };
}

/**
 * 获取指定时间戳范围的所有月份范围
 * @param {number} startTimestamp - 开始时间13位时间戳
 * @param {number} endTimestamp - 结束时间13位时间戳
 * @returns {Array} 月份范围数组
 */
const getMonthRanges = (startTimestamp, endTimestamp) => {
    const ranges = [];
    const start = dayjs(startTimestamp);
    const end = dayjs(endTimestamp);

    let current = start.startOf('month');

    while (current.isSameOrBefore(end)) {
        const monthStart = current;
        const monthEnd = current.endOf('month');

        // 确保不超出指定的结束时间
        const actualEnd = monthEnd.isAfter(end) ? end : monthEnd;
        // 确保不早于指定的开始时间
        const actualStart = monthStart.isBefore(start) ? start : monthStart;

        ranges.push({
            start: actualStart.valueOf(), // 13位时间戳
            end: actualEnd.valueOf()      // 13位时间戳
        });

        current = current.add(1, 'month');
    }

    return ranges;
};

/**
 * 按月聚合日统计数据
 * @param {Array} dailyData - 日统计数据数组
 * @returns {Array} 按月聚合后的数据
 */
const aggregateDataByMonth = (dailyData) => {
    if (!Array.isArray(dailyData) || dailyData.length === 0) {
        return [];
    }

    // 按月分组数据
    const monthlyGroups = {};

    dailyData.forEach(item => {
        // 处理时间戳或ISO字符串
        let timestamp;
        if (typeof item.start_time === 'string') {
            timestamp = dayjs(item.start_time).valueOf();
        } else {
            timestamp = parseInt(item.start_time);
        }

        const date = dayjs(timestamp);
        const monthKey = date.format('YYYY-MM');

        if (!monthlyGroups[monthKey]) {
            monthlyGroups[monthKey] = [];
        }
        monthlyGroups[monthKey].push(item);
    });

    // 聚合每月数据
    const monthlyData = Object.keys(monthlyGroups).map(monthKey => {
        const monthData = monthlyGroups[monthKey];

        // 按时间排序确保正确的开始和结束值
        monthData.sort((a, b) => {
            const timeA = typeof a.start_time === 'string'
                ? dayjs(a.start_time).valueOf()
                : parseInt(a.start_time);
            const timeB = typeof b.start_time === 'string'
                ? dayjs(b.start_time).valueOf()
                : parseInt(b.start_time);
            return timeA - timeB;
        });

        const firstDay = monthData[0];
        const lastDay = monthData[monthData.length - 1];

        // 计算当月所有日Value的总和
        const totalValue = monthData.reduce((sum, day) => {
            return sum + parseFloat(day.Value || 0);
        }, 0);

        // 构建月统计数据 - 使用13位时间戳
        const monthDate = dayjs(monthKey + '-01');
        const startTime = monthDate.startOf('month').valueOf(); // 月初时间戳
        const endTime = monthDate.add(1, 'month').startOf('month').valueOf(); // 下个月第一天时间戳

        return {
            start_time: startTime,
            begin: firstDay.begin,
            Value: totalValue.toFixed(2),
            end: lastDay.end,
            end_time: endTime,
            error: ""
        };
    });

    // 按时间排序
    return monthlyData.sort((a, b) => a.start_time - b.start_time);
};

/**
 * 按月分批请求日数据并聚合
 * @param {Object} params - 请求参数
 * @returns {Promise} 聚合后的月统计数据
 */
const getMonthlyAggregatedData = async (params) => {
    try {
        const { start_time, end_time } = params;

        if (!start_time || !end_time) {
            throw new Error('按月聚合需要提供 start_time 和 end_time 参数（13位时间戳）');
        }

        // 确保时间戳为数字类型
        const startTimestamp = parseInt(start_time);
        const endTimestamp = parseInt(end_time);



        // 获取所有月份范围
        const monthRanges = getMonthRanges(startTimestamp, endTimestamp);
        const allMonthlyData = [];



        // 按月分批请求
        for (let i = 0; i < monthRanges.length; i++) {
            const range = monthRanges[i];
            const dailyParams = {
                ...params,
                interval: 'day',
                start_time: range.start,
                end_time: range.end
            };

            try {


                const response = await request.get('/report/', { params: dailyParams });

                if (response && response.aggregated_data && response.aggregated_data.length > 0) {


                    // 聚合当月数据
                    const monthlyData = aggregateDataByMonth(response.aggregated_data);
                    if (monthlyData.length > 0) {
                        allMonthlyData.push(...monthlyData);

                    }
                } else {

                }
            } catch (error) {

                // 继续处理其他月份的数据
            }
        }



        return {
            message: "成功完成",
            code: 200,
            date: dayjs().format('YYYY-MM-DD HH:mm:ss.SSS [+0800 CST]'),
            aggregated_data: allMonthlyData.sort((a, b) => a.start_time - b.start_time)
        };

    } catch (error) {

        throw error;
    }
};

/**
 * 获取表计统计信息
 * @param {Object} params - 请求参数
 * @param {number} params.id - 表计ID（必需）
 * @param {number} params.start_time - 开始时间13位时间戳（可选）
 * @param {number} params.end_time - 结束时间13位时间戳（可选）
 * @param {string} params.interval - 时间间隔（'half_hour'|'day'|'month'|'quarter'|'year'|'hour'）（可选）
 * @param {boolean} params.aggregateToMonth - 是否聚合日数据为月数据（可选，仅当interval为month时有效）
 * @returns {Promise} 返回处理后的数据Promise
 */
export const getMeterReportApi = async (params = {}) => {
    // 参数验证
    if (!params.id) {
        return Promise.reject(new Error('表计ID是必需的'));
    }

    // 验证interval参数（如果提供）
    if (params.interval && !['half_hour', 'day', 'month', 'quarter', 'year', 'hour'].includes(params.interval)) {
        return Promise.reject(new Error('无效的interval参数'));
    }

    try {
        // 如果请求月统计且需要聚合日数据
        if (params.interval === 'month') {
            return await getMonthlyAggregatedData(params);
        }

        // 普通请求
        return request.get('/report/', { params })
            .then(sortTimeSeriesData);

    } catch (error) {

        throw error;
    }
};

/**
 * 时间戳工具函数
 */
export const timeUtils = {
    // 将日期字符串转为13位时间戳
    dateToTimestamp: (dateStr) => dayjs(dateStr).valueOf(),

    // 将13位时间戳转为日期字符串
    timestampToDate: (timestamp, format = 'YYYY-MM-DD HH:mm:ss') => dayjs(timestamp).format(format),

    // 获取今天开始时间戳
    getTodayStart: () => dayjs().startOf('day').valueOf(),

    // 获取今天结束时间戳
    getTodayEnd: () => dayjs().endOf('day').valueOf(),

    // 获取本月开始时间戳
    getMonthStart: (timestamp = Date.now()) => dayjs(timestamp).startOf('month').valueOf(),

    // 获取本月结束时间戳
    getMonthEnd: (timestamp = Date.now()) => dayjs(timestamp).endOf('month').valueOf(),

    // 获取指定月份前N个月的时间戳
    getMonthsAgo: (months, timestamp = Date.now()) => dayjs(timestamp).subtract(months, 'month').valueOf()
};

/**
 * 获取公司能耗统计报告
 * @param {Object} params - 请求参数
 * @param {number} params.id - 公司ID
 * @param {string} params.start_time - 开始时间时间戳
 * @param {string} params.end_time - 结束时间时间戳
 * @param {string} params.interval - 时间间隔（'half_hour'|'day'|'month'）
 * @param {string} params.type - 表计类型
 * @returns {Promise} 返回处理后的数据Promise
 */
export const getReportApi = async (params = {}) => {
    try {
        // 参数验证
        if (!params.id) {
            throw new Error('公司ID是必需的');
        }
        if (!params.type) {
            throw new Error('表计类型是必需的');
        }
        let firstLevelMeters = await getFirstLevelMeterList({
            company_id: params.id,
            type: params.type
        })

        const meterReportsPromises = firstLevelMeters.map(meter =>
            getMeterReportApi({
                id: meter.id,
                start_time: params.start_time,
                end_time: params.end_time,
                interval: params.interval
            })
        );

        // 等待所有表计数据获取完成
        const meterReports = await Promise.all(meterReportsPromises);

        // 提取每个表计的聚合数据
        const aggregatedDataArrays = meterReports
            .map(report => report?.aggregated_data)
            .filter(data => Array.isArray(data) && data.length > 0);

        // 处理并合并所有表计数据
        const processedData = processArrays(aggregatedDataArrays);

        return {
            code: 200,
            message: "成功",
            date: new Date().toISOString(),
            aggregated_data: processedData.map(item => ({
                ...item,
            }))
        };

    } catch (error) {

        throw error;
    }
}


/**
 * 获取公司多个表计能耗统计报告
 * @param {Object} params - 请求参数
 * @param {Array} params.meters - 表计列表
 * @param {string} params.start_time - 开始时间时间戳13位时间戳
 * @param {string} params.end_time - 结束时间时间戳13位时间戳
 * @param {string} params.interval - 时间间隔（'half_hour'|'day'|'month'）
 * @returns {Promise} 返回处理后的数据Promise
 */
export const getMetersReportApi = async (params = {}) => {
    try {

        if (!params.meters || !Array.isArray(params.meters) || params.meters.length === 0) {

            return Promise.reject(new Error('表计列表是必需的'));
        }
        const meterReportsPromises = params.meters.map(meter => {
            return getMeterReportApi({
                id: meter.id,
                start_time: params.start_time,
                end_time: params.end_time,
                interval: params.interval
            })
        }
        );

        // 等待所有表计数据获取完成
        const meterReports = await Promise.all(meterReportsPromises);

        // 提取每个表计的聚合数据
        const aggregatedDataArrays = meterReports
            .map(report => report?.aggregated_data)
            .filter(data => Array.isArray(data) && data.length > 0);

        // 处理并合并所有表计数据
        const processedData = processArrays(aggregatedDataArrays);

        return {
            code: 200,
            message: "成功",
            date: new Date().toISOString(),
            aggregated_data: processedData.map(item => ({
                ...item,
            }))
        };

    } catch (error) {

        throw error;
    }
}

//获取最新读数
export const getLatestReadApi = (params = {}) => {
    return request.get('/record/latest', { params })
}

